home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / gui / skin / skinobjects.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  13.9 KB  |  366 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. from __future__ import division
  6. import wx
  7. from util import autoassign, traceguard
  8. create_gc = wx.GraphicsContext.Create
  9. from gui.toolbox import TransparentBitmap
  10. from operator import itemgetter
  11. from cgui import Bitmap_Draw
  12. import new
  13. wx.Bitmap.Draw = new.instancemethod(Bitmap_Draw, None, wx.Bitmap)
  14.  
  15. class MarginSizer(wx.GridBagSizer):
  16.     
  17.     def __init__(self, margins, content):
  18.         wx.GridBagSizer.__init__(self)
  19.         self.SetEmptyCellSize(wx.Size(0, 0))
  20.         self.AddGrowableCol(1, 1)
  21.         self.AddGrowableRow(1, 1)
  22.         self.Add(content, (1, 1), flag = wx.EXPAND)
  23.         self.SetMargins(margins)
  24.  
  25.     
  26.     def SetMargins(self, margins):
  27.         if len(self.GetChildren()) > 2:
  28.             self.Detach(1)
  29.             self.Detach(1)
  30.         
  31.         self.Add(wx.Size(margins.left, margins.top), (0, 0))
  32.         self.Add(wx.Size(margins.right, margins.bottom), (2, 2))
  33.  
  34.  
  35.  
  36. class Margins(list):
  37.     
  38.     def __init__(self, a = None):
  39.         if a is None:
  40.             list.__init__(self, [
  41.                 0,
  42.                 0,
  43.                 0,
  44.                 0])
  45.         elif isinstance(a, basestring):
  46.             list.__init__(self, (lambda .0: for c in .0:
  47. int(c))(a.split()))
  48.         elif isinstance(a, int):
  49.             list.__init__(self, [
  50.                 a] * 4)
  51.         elif len(a) == 2:
  52.             a = [
  53.                 a[0],
  54.                 a[1],
  55.                 a[0],
  56.                 a[1]]
  57.         
  58.         list.__init__(self, (lambda .0: for c in .0:
  59. int(c))(a))
  60.  
  61.     
  62.     def Sizer(self, content):
  63.         return MarginSizer(self, content)
  64.  
  65.     left = property(itemgetter(0))
  66.     top = property(itemgetter(1))
  67.     right = property(itemgetter(2))
  68.     bottom = property(itemgetter(3))
  69.     x = property((lambda self: self[0] + self[2]))
  70.     y = property((lambda self: self[1] + self[3]))
  71.     TopLeft = property((lambda self: wx.Point(self[0], self[1])))
  72.     BottomRight = property((lambda self: wx.Point(self[2], self[3])))
  73.     
  74.     def __neg__(self):
  75.         return []([ -a for a in self ])
  76.  
  77.  
  78.  
  79. class SkinBase(object):
  80.     
  81.     def Show(self):
  82.         wxSpriteShow = wxSpriteShow
  83.         import gui.toolbox
  84.         wxSpriteShow(self)
  85.  
  86.  
  87.  
  88. class SkinRegion(SkinBase):
  89.     
  90.     def __init__(self, border = None, rounded = False, highlight = False, shadow = False):
  91.         if not isinstance(border, (type(None), wx.Pen)):
  92.             raise TypeError('border must be a Pen or None')
  93.         
  94.         autoassign(self, locals())
  95.         self.pen = None if border is None else border
  96.  
  97.     
  98.     def GetBitmap(self, size, n = 0):
  99.         tb = TransparentBitmap(size)
  100.         dc = wx.MemoryDC()
  101.         dc.SelectObject(tb)
  102.         self.draw(dc, wx.RectS(size), n)
  103.         dc.SelectObject(wx.NullBitmap)
  104.         return tb
  105.  
  106.     
  107.     def Stroke(self, dc, gc, rect, n = 0):
  108.         pen = self.pen
  109.         penw = pen.Width // 2
  110.         rect = wx.Rect(*rect)
  111.         rect.Deflate(penw, penw)
  112.         pen.SetCap(wx.CAP_PROJECTING)
  113.         gc.SetPen(pen)
  114.         dc.SetPen(pen)
  115.         dc.Brush = wx.TRANSPARENT_BRUSH
  116.         gc.Brush = wx.TRANSPARENT_BRUSH
  117.         if self.rounded:
  118.             if self.border:
  119.                 gc.DrawRoundedRectangle(*tuple(rect) + (self.rounded * 0.97,))
  120.             
  121.             rect.Inflate(penw, penw)
  122.             self.stroke_highlights_rounded(gc, rect)
  123.         elif self.border:
  124.             offset = int(pen.Width % 2 == 0)
  125.             dl = dc.DrawLine
  126.             x = wx.Point(offset, 0)
  127.             y = wx.Point(0, offset)
  128.             for a, b in [
  129.                 (rect.TopLeft, rect.BottomLeft + y),
  130.                 (rect.BottomLeft + y, rect.BottomRight + y + x),
  131.                 (rect.BottomRight + y + x, rect.TopRight + x),
  132.                 (rect.TopRight + x, rect.TopLeft)]:
  133.                 dl(*tuple(a) + tuple(b))
  134.             
  135.         
  136.         rect.Inflate(penw, penw)
  137.         self.stroke_highlights(gc, rect)
  138.  
  139.     
  140.     def stroke_highlights_rounded(self, gc, rect):
  141.         pass
  142.  
  143.     
  144.     def stroke_highlights(self, gc, rect):
  145.         hw = max(2, self.pen.Width)
  146.         seq = []
  147.         if self.highlight:
  148.             c1 = wx.Color(255, 255, 255, 100)
  149.             c2 = wx.Color(255, 255, 255, 150)
  150.             seq.extend([
  151.                 ((rect.x, rect.y), [
  152.                     (rect.x, rect.Bottom),
  153.                     (rect.x + hw, rect.Bottom - hw),
  154.                     (rect.x + hw, rect.y + hw),
  155.                     (rect.x, rect.y)], gc.CreateLinearGradientBrush(rect.x, rect.y, rect.x + hw, rect.y, c1, c2)),
  156.                 ((rect.x, rect.y), [
  157.                     (rect.Right + 1, rect.y),
  158.                     (rect.Right - hw, rect.y + hw),
  159.                     (rect.x + hw, rect.y + hw),
  160.                     (rect.x, rect.y)], gc.CreateLinearGradientBrush(rect.x, rect.y, rect.x, rect.y + hw, c1, c2))])
  161.         
  162.         if self.shadow:
  163.             sc1 = wx.Color(0, 0, 0, 50)
  164.             sc2 = wx.Color(0, 0, 0, 100)
  165.             seq.extend([
  166.                 ((rect.Right + 1, rect.Bottom + 1), [
  167.                     (rect.x, rect.Bottom + 1),
  168.                     (rect.x + hw, (rect.Bottom - hw) + 1),
  169.                     ((rect.Right - hw) + 1, (rect.Bottom - hw) + 1),
  170.                     (rect.Right + 1, rect.Bottom + 1)], gc.CreateLinearGradientBrush(rect.x, (rect.Bottom - hw) + 1, rect.x, rect.Bottom + 1, sc1, sc2)),
  171.                 ((rect.Right + 1, rect.Bottom + 1), [
  172.                     (rect.Right + 1, rect.y),
  173.                     ((rect.Right - hw) + 1, rect.y + hw),
  174.                     ((rect.Right - hw) + 1, (rect.Bottom - hw) + 1),
  175.                     (rect.Right + 1, rect.Bottom + 1)], gc.CreateLinearGradientBrush((rect.Right - hw) + 1, rect.Bottom, rect.Right + 1, rect.Bottom, sc1, sc2))])
  176.         
  177.         if seq:
  178.             for origin, pts, brush in seq:
  179.                 p = gc.CreatePath()
  180.                 p.MoveToPoint(*origin)
  181.                 for pt in pts:
  182.                     p.AddLineToPoint(*pt)
  183.                 
  184.                 gc.SetBrush(brush)
  185.                 gc.FillPath(p)
  186.             
  187.         
  188.  
  189.     
  190.     def draw(self, *a, **k):
  191.         self.Draw(*a, **k)
  192.  
  193.  
  194.  
  195. class SkinStack(list, SkinBase):
  196.     
  197.     def __init__(self, seq):
  198.         list.__init__(self, seq)
  199.         if not all((lambda .0: for elem in .0:
  200. callable(getattr(elem, 'Draw', None)))(seq)):
  201.             raise TypeError('SkinStack must be constructed with .Draw-able elements (you gave %r)' % seq)
  202.         
  203.  
  204.     
  205.     def Draw(self, dc, rect, n = 0):
  206.         for brush in reversed(self):
  207.             brush.Draw(dc, rect, n)
  208.         
  209.  
  210.     
  211.     def GetBitmap(self, size, n = 0):
  212.         tb = TransparentBitmap(size)
  213.         dc = wx.MemoryDC()
  214.         dc.SelectObject(tb)
  215.         for region in reversed(self):
  216.             region.draw(dc, wx.RectS(size), n)
  217.         
  218.         dc.SelectObject(wx.NullBitmap)
  219.         return tb
  220.  
  221.     
  222.     def ytile(self):
  223.         return all((lambda .0: for c in .0:
  224. c.ytile)(self))
  225.  
  226.     ytile = property(ytile)
  227.  
  228.  
  229. class SkinList(list, SkinBase):
  230.     
  231.     def __init__(self, seq):
  232.         list.__init__(self, seq)
  233.         if not all((lambda .0: for elem in .0:
  234. callable(getattr(elem, 'Draw', None)))(seq)):
  235.             raise TypeError('SkinStack must be constructed with .Draw-able elements (you gave %r)' % seq)
  236.         
  237.  
  238.     
  239.     def Draw(self, dc, rect, n = 0):
  240.         self[n % len(self)].Draw(dc, rect, n)
  241.  
  242.     
  243.     def ytile(self):
  244.         return all((lambda .0: for c in .0:
  245. c.ytile)(self))
  246.  
  247.     ytile = property(ytile)
  248.  
  249.  
  250. class SkinGradient(SkinRegion):
  251.     __slots__ = [
  252.         'direction',
  253.         'ytile',
  254.         'colors',
  255.         '_oldrect']
  256.     
  257.     def __init__(self, direction, colors, **opts):
  258.         SkinRegion.__init__(self, **opts)
  259.         self.direction = direction
  260.         if direction == 'horizontal':
  261.             pass
  262.         self.ytile = not (self.border)
  263.         self.colors = colors
  264.         self._oldrect = None
  265.         if self.rounded is not False or len(colors) > 2:
  266.             
  267.             self.Fill = lambda gc, x, y, w, h: wx.GraphicsContext.DrawRoundedRectangle(gc, x, y, w, h, self.rounded)
  268.         else:
  269.             self.Fill = wx.GraphicsContext.DrawRectangle
  270.  
  271.     
  272.     def __repr__(self):
  273.         return '<%s %s %r>' % (self.__class__.__name__, self.direction, self.colors)
  274.  
  275.     
  276.     def _rects(self, therect):
  277.         if therect == self._oldrect:
  278.             return self._oldrects
  279.         
  280.         x = float(therect.x)
  281.         y = float(therect.y)
  282.         w = float(therect.width)
  283.         h = float(therect.height)
  284.         vert = self.direction == 'vertical'
  285.         p1 = None(float if vert else therect.Left)
  286.         lc = len(self.colors) - 1
  287.         dx = None if vert else w / float(lc)
  288.         rects = []
  289.         for i in xrange(0, lc):
  290.             (c1, c2) = self.colors[i:i + 2]
  291.             delta = None if i not in (lc, 0) else 0
  292.             if vert:
  293.                 r = (x, p1, w, dx + delta)
  294.                 gradrect = (x, p1 - delta, x, p1 + dx + delta * 2, c1, c2)
  295.             else:
  296.                 r = (p1, y, dx + delta, h)
  297.                 gradrect = (p1 - delta, y, p1 + dx + delta * 2, y, c1, c2)
  298.             rects.append((gradrect, r))
  299.             p1 = p1 + dx
  300.         
  301.         return rects
  302.  
  303.     
  304.     def Draw(self, dc, therect, n = 0):
  305.         gc = create_gc(dc)
  306.         gc.SetPen(wx.TRANSPARENT_PEN)
  307.         createb = gc.CreateLinearGradientBrush
  308.         gc.Clip(*therect)
  309.         for gradrect, fillrect in self._rects(therect):
  310.             gc.SetBrush(createb(*gradrect))
  311.             self.Fill(gc, *fillrect)
  312.         
  313.         self.Stroke(dc, gc, therect)
  314.  
  315.  
  316.  
  317. def SkinColorCGUI(color, **opts):
  318.     SkinColor = SkinColor
  319.     import cgui
  320.     return SkinColor(color)
  321.  
  322.  
  323. class SkinColor(wx.Color, SkinRegion):
  324.     simple = False
  325.     
  326.     def __init__(self, color, **opts):
  327.         if not any((lambda .0: for key, val in .0:
  328. val)(opts.iteritems())):
  329.             c = tuple(color)
  330.             if len(c) < 4 or c[3] == 255:
  331.                 self.simple = True
  332.             
  333.         
  334.         SkinRegion.__init__(self, **opts)
  335.         wx.Color.__init__(self)
  336.         self.Set(*color)
  337.         self.ytile = not (self.border)
  338.  
  339.     
  340.     def Fill(self, dc, rect):
  341.         if self.rounded and not (self.simple):
  342.             dc.DrawRoundedRectangle(*tuple(rect) + (self.rounded,))
  343.         else:
  344.             dc.DrawRectangle(*rect)
  345.  
  346.     
  347.     def __repr__(self):
  348.         return '<%s (%s, %s, %s, %s)>' % ((self.__class__.__name__,) + tuple(self))
  349.  
  350.     
  351.     def Draw(self, dc, rect, n = 0):
  352.         brush = wx.Brush(self)
  353.         if self.simple:
  354.             dc.SetPen(wx.TRANSPARENT_PEN)
  355.             dc.SetBrush(brush)
  356.             dc.DrawRectangle(*rect)
  357.         else:
  358.             gc = create_gc(dc)
  359.             gc.SetBrush(brush)
  360.             gc.SetPen(wx.TRANSPARENT_PEN)
  361.             gc.Clip(*rect)
  362.             self.Fill(gc, rect)
  363.             self.Stroke(dc, gc, rect, n)
  364.  
  365.  
  366.